// string  number boolean

// import { type } from "os";

export const st1: string = "1231";

const num: number = 123456;

const bool: boolean = true;

// 数组1

const arr: number[] = [1, 2, 3, 4, 5];
const arr1: string[] = ["a", "b", "c"];

// any: 不建议
let a: any = 1;
a = true;
a = () => {};

// 函数
// 参数具有类型注释
// 返回类型注解
function add(x: number, y: number): number {
  return x + y;
}

add(1, 2);

add(123, 123.1);

const arr123 = ["a", "b", "c", "d"];

arr123.forEach((v, i) => {});

// 联合类型 |
// string | number

const arr22: (string | number)[] = [1, 2, 3, 4, "a", "b", "c"];

arr22.forEach((v, i) => {});

function fn(params: number | string): number {
  if (typeof params === "number") {
    return params;
  } else {
    return params.length;
  }
}

fn(123);

fn("123");

// 类型别名

const num123: number = 1111;

type qwer = number;

const num33: qwer = 2222;

// 接口：接口声明是命名对象类型的另一种方式：

interface IUser {
  name: string;
  age: number;
  sex: "男" | "女" | "ts";
}

type TUser = {
  name: string;
  age: number;
  sex: "男" | "女" | "ts";
};

interface IUser {
  code: number;
}

const o1: IUser = {
  name: "张三",
  age: 18,
  sex: "ts",
  code: 100,
};

const o2: TUser = {
  name: "张三",
  age: 18,
  sex: "ts",
};

// 面试题： type 和 interface 的区别 ？
// 1. 类型别名不得参与 在声明合并中，但接口可以。
// 2. 接口只能用于 声明对象的形状，而不是重命名基元。
// 3. 接口名称将在错误消息中显示为 总是以原来的形式出现，但仅当它们被名称使用时。

// number
// string
// undefined
// boolean
// null
// object
// []
// function
// symbol

// export let n1: object = new Number(1)
// export let s11: object = new String('1231231')
// // export let n: object = undefined
// export let n2: object = () => {}
// export let n3: object = [1,2,3,4]
// export let n4: object = { name: '张三' }

// type OO = number
// let s: OO = '1231'

// 类型断言
// 时你会得到关于 TypeScript 无法知道的值类型的信息。你可以使用类型断言来指定更具体的类型：

const el = document.getElementById("qwer") as HTMLElement;

el.addEventListener("click", (e) => {});

// 字面类型

let s1 = "123";

// null 和  undefined
// 1. 面试题： null 和 undefined的区别
// 2. typeof 检测null返回什么？ 为什么？

// 1.封装求和函数，实现不定参数的求和
// function fn1(...numbers: number[]): number {
//   return numbers.reduce((item, n) => {
//     return item + n;
//   }, 0);
// }

function fn1(...arr: number[]): number {
  return arr.reduce((p, n) => {
    return p + n;
  }, 0);
}

fn1(1);

fn1(1, 2, 3, 4, 5);

fn1(100, 200, 300, 50);
// 2.封装函数， 接受字符串类型的数组，返回数组的最长的字符串的信息

function fn2(arr: string[]) {
  let str = 0;
  arr.map((v) => {
    if (v.length > str) {
      str = v.length;
    }
    return str;
  });

  return arr.sort((a, b) => {
    return b.length - a.length
  })[0].length
}
